Advance Lane Detection¶
The goals / steps of this project are the following:¶
- Compute the camera calibration matrix and distortion coefficients given a set of chessboard images.
- Apply a distortion correction to raw images.
- Use color transforms, gradients, etc., to create a thresholded binary image.
- Apply a perspective transform to rectify binary image ("birds-eye view").
- Detect lane pixels and fit to find the lane boundary.
- Determine the curvature of the lane and vehicle position with respect to center.
- Warp the detected lane boundaries back onto the original image.
- Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.
In [1]:
import cv2
import glob
import math
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
import os.path
%matplotlib inline
Camera Calibration¶
In [2]:
# load calibration
import calibration as cc
mtx, dist = cc.getCalibration()
Camera Calibration Vizualization¶
In [3]:
fig = plt.figure()
fig.set_size_inches(50,50)
path = "./output_images/corners_found_*.jpg"
images = glob.glob(path)
total_image_count = len(images)
image_count = 1
for i in images:
img = cv2.imread(i)
ax = fig.add_subplot(math.ceil(total_image_count / 3), 3, image_count)
ax.imshow(img)
ax.axis('off')
ax.set_title('DrawChessboardCorners', fontsize=30)
image_count += 1
In [4]:
fig = plt.figure()
fig.set_size_inches(50,50)
path = "./test_images/*.jpg"
images = glob.glob(path)
total_image_count = len(images)
image_count = 1
for i in images:
img = cv2.imread(i)
dst = cv2.undistort(img, mtx, dist, None, mtx)
cv2.imwrite('./output_images/undistorted_' + os.path.split(i)[-1], dst)
ax = fig.add_subplot(total_image_count, 2, image_count)
ax.imshow(img)
ax.axis('off')
ax.set_title('Original Image ' + os.path.split(i)[-1], fontsize=30)
image_count += 1
ax = fig.add_subplot(math.ceil(total_image_count), 2, image_count)
ax.imshow(dst)
ax.axis('off')
ax.set_title('Undistorted Image ' + os.path.split(i)[-1], fontsize=30)
image_count += 1
Thresholding¶
In [5]:
import glob
import os.path
import thresholding as th
path = "./output_images/undistorted_*.jpg"
images = glob.glob(path)
fig = plt.figure()
fig.set_size_inches(50,50)
total_image_count = len(images)
image_count = 1
for i in images:
image = mpimg.imread(i)
combined_binary, s_binary, sobel_binary = th.combined_threshold(image)
cv2.imwrite('./output_images/threshold_' + os.path.split(i)[-1], combined_binary)
# Plotting thresholded images
ax = fig.add_subplot(total_image_count, 4, image_count)
ax.imshow(image)
ax.axis('off')
ax.set_title('Original Image ' + os.path.split(i)[-1], fontsize=30)
image_count += 1
ax = fig.add_subplot(total_image_count, 4, image_count)
ax.imshow(combined_binary, cmap='gray')
ax.axis('off')
ax.set_title('Combined S channel and gradient thresholds ', fontsize=30)
image_count += 1
ax = fig.add_subplot(total_image_count, 4, image_count)
ax.imshow(s_binary, cmap='gray')
ax.axis('off')
ax.set_title('s_binary ', fontsize=30)
image_count += 1
ax = fig.add_subplot(total_image_count, 4, image_count)
ax.imshow(sobel_binary, cmap='gray')
ax.axis('off')
ax.set_title('sobel_binary ', fontsize=30)
image_count += 1
Perspective transform¶
In [3]:
import glob
import os.path
from cv2 import IMREAD_GRAYSCALE
path = "./output_images/threshold_undistorted_test2.jpg"
images = glob.glob(path)
image = mpimg.imread(images[0])
img_size = (image.shape[1], image.shape[0])
fig = plt.figure()
fig.set_size_inches(50,50)
image_count = 1
offset = 200
src = np.float32([
[ 588, 446 ],
[ 691, 446 ],
[ 1126, 673 ],
[ 153 , 673 ]])
dst = np.float32([[offset, 0], [img_size[0] - offset, 0], [img_size[0] - offset, img_size[1]], [offset, img_size[1]]])
M = cv2.getPerspectiveTransform(src, dst)
Minv = cv2.getPerspectiveTransform(dst, src)
binary_warped = cv2.warpPerspective(image, M, img_size, flags=cv2.INTER_LINEAR)
# Plotting thresholded images
ax = fig.add_subplot(1, 2, image_count)
ax.imshow(image, cmap='gray')
ax.axis('off')
ax.set_title('Original Image ' + os.path.split(images[0])[-1], fontsize=30)
image_count += 1
ax = fig.add_subplot(1, 2, image_count)
ax.imshow(binary_warped, cmap='gray')
ax.axis('off')
ax.set_title('Binary Warped ' + os.path.split(images[0])[-1], fontsize=30)
image_count += 1
cv2.imwrite('./output_images/Warped_' + os.path.split(images[0])[-1], binary_warped)
Out[3]:
Lane Detections¶
In [7]:
import lanes
import matplotlib.pyplot as plt
## Visualization
out_img, left_fit, right_fit = lanes.detect_lanes_full(binary_warped)
# ploty is just the coordinates for y axis: 0 - 719
ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
plt.imshow(out_img)
plt.plot(left_fitx, ploty, color='yellow')
plt.plot(right_fitx, ploty, color='yellow')
plt.xlim(0, 1280)
plt.ylim(720, 0)
plt.title('Lane Detected')
Out[7]:
Radius of Curvature¶
In [8]:
import lanes
# left_curverad, right_curverad = get_radius(left_fitx, right_fitx, ploty)
left_curverad, right_curverad = lanes.get_radius(left_fitx, right_fitx, ploty)
# Now our radius of curvature is in meters
# print("left lane radius:" + left_curverad + 'm ' + "right lane radius:" + right_curverad + 'm ' + "Lane length: " + (right_curverad - left_curverad))
print(left_curverad, 'm', right_curverad, 'm')
print("left lane radius:" , left_curverad , 'm ' , "right lane radius:" , right_curverad , 'm ' , "Lane length: " , (right_curverad - left_curverad))
Plot the detected lane boundaries back onto the original image.¶
In [9]:
import lanes
# Create an image to draw the lines on
path = "./output_images/undistorted_test2.jpg"
images = glob.glob(path)
undistorted = mpimg.imread(images[0])
img_size = (undistorted.shape[1], undistorted.shape[0])
result = lanes.plot_lanes(undistorted, binary_warped, Minv, img_size, left_fitx, right_fitx, ploty)
plt.imshow(result)
cv2.imwrite('./output_images/Final_test2.jpg', result)
Out[9]:
Generate Video¶
In [4]:
# Import everything needed to edit/save/watch video clips
from IPython.display import HTML
import lanes
from moviepy.editor import VideoFileClip
import pipeline as p
import thresholding as th
def process_image(img):
undistorted = cv2.undistort(img, mtx, dist, None, mtx)
ploty = np.linspace(0, undistorted.shape[0]-1, undistorted.shape[0] )
combined_binary, s_binary, sobel_binary = th.combined_threshold(undistorted)
img_size = (undistorted.shape[1], undistorted.shape[0])
binary_warped = cv2.warpPerspective(combined_binary, M, img_size, flags=cv2.INTER_LINEAR)
left_fit = []
right_fit = []
valid = True
incremental = False
if line.num_invalid < line.MAX_INVALID:
incremental = True
_, left_fit, right_fit, valid = lanes.detect_lanes_incremental(binary_warped, line.left_fit, line.right_fit)
else:
line.reset()
_, left_fit, right_fit = lanes.detect_lanes_full(binary_warped)
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
left_curverad, right_curverad = lanes.get_radius(left_fitx, right_fitx, ploty)
lane_length = right_curverad - left_curverad
# if valid:
# if ((right_curverad/left_curverad) > 5) or ((right_curverad/left_curverad) < 0.2):
# print("Lane curves too off: ", right_curverad/left_curverad)
# valid = False
mid_point = img_size[0]/2
valid = p.are_lines_valid(mid_point, left_fitx, right_fitx)
if ((not valid) and incremental):
_, left_fit, right_fit = lanes.detect_lanes_full(binary_warped)
incremental = False
valid = True
left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]
right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]
left_curverad, right_curverad = lanes.get_radius(left_fitx, right_fitx, ploty)
lane_length = right_curverad - left_curverad
# if valid:
# if ((right_curverad/left_curverad) > 5) or ((right_curverad/left_curverad) < 0.2):
# print("Lane curves too off: ", right_curverad/left_curverad)
# valid = False
mid_point = img_size[0]/2
valid = p.are_lines_valid(mid_point, left_fitx, right_fitx)
if valid:
print("Success !!!!!!!!!!")
# valid = are_lines_valid(lane_length)
line.detected = valid
if valid:
line.num_invalid = 0
line.update_fit(left_fit, right_fit)
line.update_points(left_fitx, right_fitx)
else:
line.num_invalid += 1
l = len(line.recent_xfitted_left)
if l > 0:
left_fit = line.left_fit
right_fit = line.right_fit
left_fitx, right_fitx = line.get_points()
line.update_fit(left_fit, right_fit)
line.update_points(left_fitx, right_fitx)
if not (valid and incremental and (line.num_invalid == 0)):
print("Valid: ", valid, " Incremental: ", incremental, line.num_invalid, len(line.recent_xfitted_left), len(line.recent_xfitted_right))
l = len(line.recent_xfitted_left)
if l > 0:
left_fitx, right_fitx = line.get_points_avg()
# left_fitx, right_fitx = line.get_points()
result = lanes.plot_lanes(undistorted, binary_warped, Minv, img_size, left_fitx, right_fitx, ploty)
else:
result = undistorted
return result
In [5]:
line = p.Line()
output = 'project_video_marked.mp4'
clip1 = VideoFileClip("project_video.mp4")
# clip = VideoFileClip("project_video.mp4")
# clip1 = clip.subclip(35,45)
output_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!
%time output_clip.write_videofile(output, audio=False)
In [ ]:
output = 'challenge_video_marked.mp4'
clip1 = VideoFileClip("challenge_video.mp4")
output_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!
%time output_clip.write_videofile(output, audio=False)
In [ ]:
output = 'harder_challenge_video_marked.mp4'
clip1 = VideoFileClip("harder_challenge_video.mp4")
output_clip = clip1.fl_image(process_image) #NOTE: this function expects color images!!
%time output_clip.write_videofile(output, audio=False)
In [ ]: